package solutions.ferpa.ztest.intf;

import br.com.telescope.adsrt.dom.DomDate;
import br.com.telescope.adsrt.dom.DomFlag;
import br.com.telescope.adsrt.dom.DomId;
import br.com.telescope.adsrt.dom.DomInteger;
import br.com.telescope.adsrt.dom.DomLogin;
import br.com.telescope.adsrt.dom.DomOption;
import br.com.telescope.adsrt.dom.DomText;
import br.com.telescope.adsrt.dom.DomTime;
import br.com.telescope.adsrt.dom.DomUpper;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.adsrt.lib.AdsException;
import br.com.telescope.adsrt.lib.Field;
import br.com.telescope.adsrt.lib.Form;
import br.com.telescope.sql.ModelQuery;
import br.com.telescope.t2.EntityBinding;
import br.com.telescope.t2.ModuleNavigator;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.exception.ApplicationRuntimeException;
import br.com.telescope.t2.feature.DeleteFeature;
import br.com.telescope.t2.feature.InsertFeature;
import br.com.telescope.t2.feature.ListFeature;
import br.com.telescope.t2.feature.LookupFeature;
import br.com.telescope.t2.feature.QueryFeature;
import br.com.telescope.t2.feature.UpdateFeature;
import br.com.telescope.t2.feature.ViewFeature;
import br.com.telescope.util.ObjectUtil;
import java.util.ArrayList;
import java.util.List;
import solutions.ferpa.ztest.ent.*;

/**
 * Ensaios livre nas bancadas.
 * <p>
 * Interface para manutenção de Ensaio Livre na bancada (sem solicitação 
 * de ensaio).
 * <P>
 * Telescope origin: ZTEST.CAD_ENSAIO_LIVRE
 * <P>
 * Base entity: ZTEST.ENSAIO_BANCADA
 * <P>
 * @author TELESCOPE - Build task T2 Web Interface Generator
 * <P>
 * @version 0.1
 */
public class CadEnsaioLivre extends ServiceModel {
    
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    public static final String GLOBAL_NAME = "ZTEST.CAD_ENSAIO_LIVRE";
    
    @Override
    public String globalName() {
        return GLOBAL_NAME;
    }
    
    {
        setTitle("Ensaios livre nas bancadas");
    }
    
    protected EntEnsaioBancada base;
    protected EntInstrumentoEnsaio banc;
    protected EntModeloHidrometro mldh;
    protected EntPessoa oper;
    protected EntPlanoExecucao plex;
    protected EntTipoInstrumentoEnsaio tpbc;
    protected EntUsuarios uopr;
    protected EntEnsaioBancada rec; // NEED_TJW1_COMPATIBILITY
    
    // Service parameters
    private DomId pIdSolicitacaoEnsaio;
    
    // Record items
    private DomId aSequenciaAutomatica;
    private DomOption aSituacao;
    private DomOption aSituacaoEnsaioHidrostatico;
    private DomOption aSituacaoEnsaioVisual;
    private DomDate aDataInicioEnsaio;
    private DomTime aHoraInicioEnsaio;
    private DomDate aDataFimEnsaio;
    private DomTime aHoraFimEnsaio;
    private DomText aNumeroLaudo;
    private DomInteger aQuantidadeHidrometros;
    private DomInteger aQuantidadeHidrometrosAprovados;
    private DomInteger aQuantidadeHidrometrosReprovados;
    private DomId aId;
    private DomId aSolicitacaoEnsaioId;
    private DomId aBancadaEnsaioId;
    private DomId aOperadorEnsaioId;
    private DomId aPlanoExecucaoId;
    private DomId aModeloHidrometroId;
    private DomUpper aBancNome;
    private DomUpper aMldhCodigo;
    private DomText aMldhDescricao;
    private DomUpper aOperNomeApresentacao;
    private DomFlag aOperAtivo;
    private DomUpper aOperCodigo;
    private DomId aOperTipoPessoaId;
    private DomUpper aPlexNome;
    private DomOption aPlexSituacao;
    private DomUpper aTpbcNome;
    private DomLogin aUoprLogin;
    
    // Query items
    private DomUpper qTpbcNome;
    private DomOption qSituacaoEnsaioHidrostatico;
    private DomUpper qMldhCodigo;
    private DomUpper qOperCodigo;
    private DomOption qSituacaoEnsaioVisual;
    private DomUpper qPlexNome;
    private DomDate qDataInicioEnsaio;
    private DomInteger qQuantidadeHidrometros;
    private DomUpper qOperNomeApresentacao;
    private DomDate qDataFimEnsaio;
    private DomOption qSituacao;
    private DomUpper qBancNome;
    private DomId qSequenciaAutomatica;
    private DomLogin qUoprLogin;
    
    @Override
    public String getBaseSql() {
        return "select BASE.*"
                + " , BANC.NOME as BANC_NOME"
                + " , MLDH.CODIGO as MLDH_CODIGO"
                + " , MLDH.DESCRICAO as MLDH_DESCRICAO"
                + " , OPER.NOME_APRESENTACAO as OPER_NOME_APRESENTACAO"
                + " , OPER.ATIVO as OPER_ATIVO"
                + " , OPER.CODIGO as OPER_CODIGO"
                + " , OPER.TIPO_PESSOA_ID as OPER_TIPO_PESSOA_ID"
                + " , PLEX.NOME as PLEX_NOME"
                + " , PLEX.SITUACAO as PLEX_SITUACAO"
                + " , TPBC.NOME as TPBC_NOME"
                + " , UOPR.LOGIN as UOPR_LOGIN"
                + " , BANC.ID as Z_BANC_ID"
                + " , MLDH.ID as Z_MLDH_ID"
                + " , OPER.ID as Z_OPER_ID"
                + " , PLEX.ID as Z_PLEX_ID"
                + " , TPBC.ID as Z_TPBC_ID"
                + " , UOPR.ID as Z_UOPR_ID"
                + " from ENSAIO_BANCADA BASE"
                + " join INSTRUMENTO_ENSAIO BANC on BANC.ID = BASE.BANCADA_ENSAIO_ID"
                + " join TIPO_INSTRUMENTO_ENSAIO TPBC on TPBC.ID = BANC.TIPO_INSTRUMENTO_ENSAIO_ID"
                + " join MODELO_HIDROMETRO MLDH on MLDH.ID = BASE.MODELO_HIDROMETRO_ID"
                + " join PESSOA OPER on OPER.ID = BASE.OPERADOR_ENSAIO_ID"
                + " left join USUARIOS UOPR on UOPR.ID = OPER.USUARIO_ASSOCIADO_ID"
                + " join PLANO_EXECUCAO PLEX on PLEX.ID = BASE.PLANO_EXECUCAO_ID";
    }
    
    @Override
    public String getBaseSqlWhereClause() {
        
        return " where base.solicitacao_ensaio_id is null";
    }
    
    @Override
    public void initAttributes() {
        
        aSequenciaAutomatica = new DomId();
        aSequenciaAutomatica.context(ctx).name("SEQUENCIA_AUTOMATICA").label("Sequência automatica");
        
        aSituacao = new DomOption();
        aSituacao.context(ctx).name("SITUACAO").label("Situação da execução").group(true);
        aSituacao.addOption("P", "Pendente");
        aSituacao.addOption("E", "Em execução");
        aSituacao.addOption("F", "Finalizado");
        aSituacao.addOption("C", "Cancelado");
        aSituacao.addOption("X", "Executado");
        aSituacao.setDefaultValue("P");
        
        aSituacaoEnsaioHidrostatico = new DomOption();
        aSituacaoEnsaioHidrostatico.context(ctx).name("SITUACAO_ENSAIO_HIDROSTATICO").label("Situação do ensaio hidrostático").group(true);
        aSituacaoEnsaioHidrostatico.addOption("Z", "A realizar");
        aSituacaoEnsaioHidrostatico.addOption("A", "Aprovado");
        aSituacaoEnsaioHidrostatico.addOption("R", "Reprovado");
        aSituacaoEnsaioHidrostatico.setDefaultValue("Z");
        
        aSituacaoEnsaioVisual = new DomOption();
        aSituacaoEnsaioVisual.context(ctx).name("SITUACAO_ENSAIO_VISUAL").label("Situação do ensaio visual").group(true);
        aSituacaoEnsaioVisual.addOption("Z", "A realizar");
        aSituacaoEnsaioVisual.addOption("A", "Aprovado");
        aSituacaoEnsaioVisual.addOption("R", "Reprovado");
        aSituacaoEnsaioVisual.setDefaultValue("Z");
        
        aDataInicioEnsaio = new DomDate();
        aDataInicioEnsaio.context(ctx).name("DATA_INICIO_ENSAIO").label("Data de início do ensaio");
        
        aHoraInicioEnsaio = new DomTime();
        aHoraInicioEnsaio.context(ctx).name("HORA_INICIO_ENSAIO").label("Hora do início do ensaio");
        
        aDataFimEnsaio = new DomDate();
        aDataFimEnsaio.context(ctx).name("DATA_FIM_ENSAIO").label("Data do fim do ensaio");
        
        aHoraFimEnsaio = new DomTime();
        aHoraFimEnsaio.context(ctx).name("HORA_FIM_ENSAIO").label("Hora do fim do ensaio");
        
        aNumeroLaudo = new DomText();
        aNumeroLaudo.context(ctx).name("NUMERO_LAUDO").label("Número do laudo");
        
        aQuantidadeHidrometros = new DomInteger();
        aQuantidadeHidrometros.context(ctx).name("QUANTIDADE_HIDROMETROS").label("Quantidade de hidrômetros");
        
        aQuantidadeHidrometrosAprovados = new DomInteger();
        aQuantidadeHidrometrosAprovados.context(ctx).name("QUANTIDADE_HIDROMETROS_APROVADOS").label("Quantidade de hidrômetros aprovados");
        aQuantidadeHidrometrosAprovados.setDefaultValue("0");
        
        aQuantidadeHidrometrosReprovados = new DomInteger();
        aQuantidadeHidrometrosReprovados.context(ctx).name("QUANTIDADE_HIDROMETROS_REPROVADOS").label("Quantidade de hidrômetros reprovados");
        aQuantidadeHidrometrosReprovados.setDefaultValue("0");
        
        aId = new DomId();
        aId.context(ctx).name("ID").label("Id");
        
        aSolicitacaoEnsaioId = new DomId();
        aSolicitacaoEnsaioId.context(ctx).name("SOLICITACAO_ENSAIO_ID").label("Solicitação do ensaio");
        
        aBancadaEnsaioId = new DomId();
        aBancadaEnsaioId.context(ctx).name("BANCADA_ENSAIO_ID").label("Bancada do ensaio");
        
        aOperadorEnsaioId = new DomId();
        aOperadorEnsaioId.context(ctx).name("OPERADOR_ENSAIO_ID").label("Operador do ensaio");
        
        aPlanoExecucaoId = new DomId();
        aPlanoExecucaoId.context(ctx).name("PLANO_EXECUCAO_ID").label("Plano de execução");
        
        aModeloHidrometroId = new DomId();
        aModeloHidrometroId.context(ctx).name("MODELO_HIDROMETRO_ID").label("Modelo de hidrômetro");
        
        aBancNome = new DomUpper();
        aBancNome.context(ctx).name("BANC_NOME").label("Sigla do instrumento (tag)");
        aBancNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from INSTRUMENTO_ENSAIO BANC"
                + " where banc.tipo_instrumento_ensaio_id in "
                + "    (select tpbc.id "
                + "       from tipo_instrumento_ensaio tpbc"
                + "     where tpbc.e_componente = 'N' ))", "q"));
        aBancNome.setAutocompleteLength(0);
        
        aMldhCodigo = new DomUpper();
        aMldhCodigo.context(ctx).name("MLDH_CODIGO").label("Código do modelo de hidrômetro");
        aMldhCodigo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT MDLH.CODIGO as valor"
                + "     , MDLH.CODIGO || MDLH.DESCRICAO as pesquisar"
                + "     , MDLH.CODIGO || ' #' || MDLH.DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MDLH"
                + " order by  MDLH.DESCRICAO)", "q"));
        
        aMldhDescricao = new DomText();
        aMldhDescricao.context(ctx).name("MLDH_DESCRICAO").label("Descrição do hidrômetro");
        aMldhDescricao.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT DESCRICAO as valor"
                + " , DESCRICAO as pesquisar"
                + " , DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MLDH)", "q"));
        aMldhDescricao.setAutocompleteLength(2);
        
        aOperNomeApresentacao = new DomUpper();
        aOperNomeApresentacao.context(ctx).name("OPER_NOME_APRESENTACAO").label("Nome completo da pessoa");
        aOperNomeApresentacao.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME_APRESENTACAO as valor"
                + " , NOME_APRESENTACAO as pesquisar"
                + " , NOME_APRESENTACAO as descricao"
                + " from PESSOA OPER"
                + " where oper.ativo = 'S' and oper.usuario_associado_id is not null)", "q"));
        aOperNomeApresentacao.setAutocompleteLength(2);
        
        aOperAtivo = new DomFlag();
        aOperAtivo.context(ctx).name("OPER_ATIVO").label("Ativo (pessoa ok)");
        aOperAtivo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT ATIVO as valor"
                + " , ATIVO as pesquisar"
                + " , ATIVO as descricao"
                + " from PESSOA OPER"
                + " where oper.ativo = 'S' and oper.usuario_associado_id is not null)", "q"));
        aOperAtivo.setAutocompleteLength(2);
        aOperAtivo.setDefaultValue("S");
        
        aOperCodigo = new DomUpper();
        aOperCodigo.context(ctx).name("OPER_CODIGO").label("Código da pessoa");
        aOperCodigo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT CODIGO as valor"
                + " , CODIGO as pesquisar"
                + " , CODIGO as descricao"
                + " from PESSOA OPER"
                + " where oper.ativo = 'S' and oper.usuario_associado_id is not null)", "q"));
        aOperCodigo.setAutocompleteLength(2);
        
        aOperTipoPessoaId = new DomId();
        aOperTipoPessoaId.context(ctx).name("OPER_TIPO_PESSOA_ID").label("Tipo da pessoa");
        aOperTipoPessoaId.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT TIPO_PESSOA_ID as valor"
                + " , TIPO_PESSOA_ID as pesquisar"
                + " , TIPO_PESSOA_ID as descricao"
                + " from PESSOA OPER"
                + " where oper.ativo = 'S' and oper.usuario_associado_id is not null)", "q"));
        aOperTipoPessoaId.setAutocompleteLength(2);
        
        aPlexNome = new DomUpper();
        aPlexNome.context(ctx).name("PLEX_NOME").label("Nome do plano de execução");
        aPlexNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from PLANO_EXECUCAO PLEX"
                + " where plex.situacao = 'A')", "q"));
        aPlexNome.setAutocompleteLength(2);
        
        aPlexSituacao = new DomOption();
        aPlexSituacao.context(ctx).name("PLEX_SITUACAO").label("Situação do plano").group(true);
        aPlexSituacao.addOption("E", "Em elaboração");
        aPlexSituacao.addOption("A", "Aprovado");
        aPlexSituacao.addOption("D", "Descontinuado");
        aPlexSituacao.setDefaultValue("E");
        
        aTpbcNome = new DomUpper();
        aTpbcNome.context(ctx).name("TPBC_NOME").label("Tipo do instrumento");
        aTpbcNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from TIPO_INSTRUMENTO_ENSAIO TPBC"
                + " where tpbc.e_componente = 'N')", "q"));
        aTpbcNome.setAutocompleteLength(0);
        
        aUoprLogin = new DomLogin();
        aUoprLogin.context(ctx).name("UOPR_LOGIN").label("Usuário (operador)");
        aUoprLogin.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT LOGIN as valor"
                + " , LOGIN as pesquisar"
                + " , LOGIN as descricao"
                + " from USUARIOS UOPR"
                + " where uopr.ativo = 'S')", "q"));
        aUoprLogin.setAutocompleteLength(1);
        
        
        qTpbcNome = new DomUpper();
        qTpbcNome.context(ctx).name("TPBC_NOME").label("Tipo do instrumento");
        qTpbcNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from TIPO_INSTRUMENTO_ENSAIO TPBC"
                + " where tpbc.e_componente = 'N')", "q"));
        qTpbcNome.setAutocompleteLength(0);
        
        qSituacaoEnsaioHidrostatico = new DomOption();
        qSituacaoEnsaioHidrostatico.context(ctx).name("SITUACAO_ENSAIO_HIDROSTATICO").label("Situação do ensaio hidrostático");
        qSituacaoEnsaioHidrostatico.addOption("Z", "A realizar");
        qSituacaoEnsaioHidrostatico.addOption("A", "Aprovado");
        qSituacaoEnsaioHidrostatico.addOption("R", "Reprovado");
        
        qMldhCodigo = new DomUpper();
        qMldhCodigo.context(ctx).name("MLDH_CODIGO").label("Código do modelo de hidrômetro");
        qMldhCodigo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT MDLH.CODIGO as valor"
                + "     , MDLH.CODIGO || MDLH.DESCRICAO as pesquisar"
                + "     , MDLH.CODIGO || ' #' || MDLH.DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MDLH"
                + " order by  MDLH.DESCRICAO)", "q"));
        
        qOperCodigo = new DomUpper();
        qOperCodigo.context(ctx).name("OPER_CODIGO").label("Código da pessoa");
        qOperCodigo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT CODIGO as valor"
                + " , CODIGO as pesquisar"
                + " , CODIGO as descricao"
                + " from PESSOA OPER"
                + " where oper.ativo = 'S' and oper.usuario_associado_id is not null)", "q"));
        qOperCodigo.setAutocompleteLength(2);
        
        qSituacaoEnsaioVisual = new DomOption();
        qSituacaoEnsaioVisual.context(ctx).name("SITUACAO_ENSAIO_VISUAL").label("Situação do ensaio visual");
        qSituacaoEnsaioVisual.addOption("Z", "A realizar");
        qSituacaoEnsaioVisual.addOption("A", "Aprovado");
        qSituacaoEnsaioVisual.addOption("R", "Reprovado");
        
        qPlexNome = new DomUpper();
        qPlexNome.context(ctx).name("PLEX_NOME").label("Nome do plano de execução");
        qPlexNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from PLANO_EXECUCAO PLEX"
                + " where plex.situacao = 'A')", "q"));
        qPlexNome.setAutocompleteLength(2);
        
        qDataInicioEnsaio = new DomDate();
        qDataInicioEnsaio.context(ctx).name("DATA_INICIO_ENSAIO").label("Data de início do ensaio");
        
        qQuantidadeHidrometros = new DomInteger();
        qQuantidadeHidrometros.context(ctx).name("QUANTIDADE_HIDROMETROS").label("Quantidade de hidrômetros");
        
        qOperNomeApresentacao = new DomUpper();
        qOperNomeApresentacao.context(ctx).name("OPER_NOME_APRESENTACAO").label("Nome completo da pessoa");
        qOperNomeApresentacao.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME_APRESENTACAO as valor"
                + " , NOME_APRESENTACAO as pesquisar"
                + " , NOME_APRESENTACAO as descricao"
                + " from PESSOA OPER"
                + " where oper.ativo = 'S' and oper.usuario_associado_id is not null)", "q"));
        qOperNomeApresentacao.setAutocompleteLength(2);
        
        qDataFimEnsaio = new DomDate();
        qDataFimEnsaio.context(ctx).name("DATA_FIM_ENSAIO").label("Data do fim do ensaio");
        
        qSituacao = new DomOption();
        qSituacao.context(ctx).name("SITUACAO").label("Situação da execução");
        qSituacao.addOption("P", "Pendente");
        qSituacao.addOption("E", "Em execução");
        qSituacao.addOption("F", "Finalizado");
        qSituacao.addOption("C", "Cancelado");
        qSituacao.addOption("X", "Executado");
        
        qBancNome = new DomUpper();
        qBancNome.context(ctx).name("BANC_NOME").label("Sigla do instrumento (tag)");
        qBancNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from INSTRUMENTO_ENSAIO BANC"
                + " where banc.tipo_instrumento_ensaio_id in "
                + "    (select tpbc.id "
                + "       from tipo_instrumento_ensaio tpbc"
                + "     where tpbc.e_componente = 'N' ))", "q"));
        qBancNome.setAutocompleteLength(0);
        
        qSequenciaAutomatica = new DomId();
        qSequenciaAutomatica.context(ctx).name("SEQUENCIA_AUTOMATICA").label("Sequência automatica");
        
        qUoprLogin = new DomLogin();
        qUoprLogin.context(ctx).name("UOPR_LOGIN").label("Usuário (operador)");
        qUoprLogin.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT LOGIN as valor"
                + " , LOGIN as pesquisar"
                + " , LOGIN as descricao"
                + " from USUARIOS UOPR"
                + " where uopr.ativo = 'S')", "q"));
        qUoprLogin.setAutocompleteLength(1);
    }
    
    @Override
    public void initParameters() {
        pIdSolicitacaoEnsaio = new DomId(ctx, "ID_SOLICITACAO_ENSAIO", "Solicitação do ensaio");
        pIdSolicitacaoEnsaio.setValue(ctx.getParameter("P_ID_SOLICITACAO_ENSAIO"));
        pIdSolicitacaoEnsaio.setSqlExpression("SOLICITACAO_ENSAIO_ID");
        if (pIdSolicitacaoEnsaio.isNotNull()) {
            aSolicitacaoEnsaioId.setValue(pIdSolicitacaoEnsaio.getValue());
        }
    }
    
    @Override
    public List<Field> getParameters() {
        if (allParameters == null) {
            allParameters = new ArrayList<Field>();
            allParameters.add(pIdSolicitacaoEnsaio);
        }
        return allParameters;
    }
    
    @Override
    public void copyBindParameters() {
        EntEnsaioBancada record = getRecord();
        if (pIdSolicitacaoEnsaio.isNotNull()) {
            record.setSolicitacaoEnsaioId(pIdSolicitacaoEnsaio.getValue());
        }
    }
    
    @Override
    public void retrieveBindParameters() {
        pIdSolicitacaoEnsaio.setValue(getRecord().valueOfSolicitacaoEnsaioId());
    }
    
    @Override
    public void initEntityBindings() {
        EntityBinding binding;
        
        binding = new EntityBinding("ZTEST.MODELO_HIDROMETRO", "MLDH", "Z_MLDH_ID", "ZTEST.CAD_MODELO_HIDROMETRO.VIEW");
        binding.addFields(aMldhCodigo, aMldhDescricao);
        entityBindings.add(binding);
        
        binding = new EntityBinding("ZTEST.PLANO_EXECUCAO", "PLEX", "Z_PLEX_ID", "ZTEST.CAD_PLANO_EXECUCAO.VIEW");
        binding.addFields(aPlexNome, aPlexSituacao);
        entityBindings.add(binding);
        
        binding = new EntityBinding("ZTEST.TIPO_INSTRUMENTO_ENSAIO", "TPBC", "Z_TPBC_ID", "ZTEST.CAD_TIPO_DISPOSITIVO_ENSAIO.VIEW");
        binding.addFields(aTpbcNome);
        entityBindings.add(binding);
    }
    
    @Override
    public String getQueryPkColumn() {
        return "BASE.ID";
    }
    
    @Override
    public void setId(String value) {
        this.aId.setValue(value);
    }
    
    @Override
    public EntEnsaioBancada getRecord() {
        if (base == null) {
            base = new EntEnsaioBancada(ctx);
            rec = base;
        }
        return this.base;
    }
    
    @Override
    public String getContextName() {
        return aSequenciaAutomatica.toText();
    }
    
    @Override
    public String getDefaultOrderBy() {
        return "SEQUENCIA_AUTOMATICA, BANC_NOME, TPBC_NOME, MLDH_CODIGO";
    }
    
    @Override
    public void translateInsertFks(Form form) {
        ModelQuery query;
        
        // BANCADA_ENSAIO_ID
        try {
            if (form.hasFields("BANC_NOME")) {
                query = createQuery()
                        .select("BANC.ID")
                        .from("INSTRUMENTO_ENSAIO", "BANC")
                        .where("banc.tipo_instrumento_ensaio_id in "
                        + "    (select tpbc.id "
                        + "       from tipo_instrumento_ensaio tpbc"
                        + "     where tpbc.e_componente = 'N' )")
                        .filter("BANC.NOME", form.get("BANC_NOME"))
                        ;
                base.setBancadaEnsaioId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // MODELO_HIDROMETRO_ID
        try {
            if (form.hasFields("MLDH_CODIGO")) {
                query = createQuery()
                        .select("MLDH.ID")
                        .from("MODELO_HIDROMETRO", "MLDH")
                        .filter("MLDH.CODIGO", form.get("MLDH_CODIGO"))
                        ;
                base.setModeloHidrometroId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // OPERADOR_ENSAIO_ID
        try {
            if (form.hasFields("OPER_NOME_APRESENTACAO")) {
                query = createQuery()
                        .select("OPER.ID")
                        .from("PESSOA", "OPER")
                        .where("oper.ativo = 'S' and oper.usuario_associado_id is not null")
                        .filter("OPER.NOME_APRESENTACAO", form.get("OPER_NOME_APRESENTACAO"))
                        ;
                base.setOperadorEnsaioId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // PLANO_EXECUCAO_ID
        try {
            if (form.hasFields("PLEX_NOME")) {
                query = createQuery()
                        .select("PLEX.ID")
                        .from("PLANO_EXECUCAO", "PLEX")
                        .where("plex.situacao = 'A'")
                        .filter("PLEX.NOME", form.get("PLEX_NOME"))
                        ;
                base.setPlanoExecucaoId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @Override
    public void translateUpdateFks(Form form) {
        ModelQuery query;
        
        // BANCADA_ENSAIO_ID
        try {
            if (form.hasFields("BANC_NOME")) {
                query = createQuery()
                        .select("BANC.ID")
                        .from("INSTRUMENTO_ENSAIO", "BANC")
                        .where("banc.tipo_instrumento_ensaio_id in "
                        + "    (select tpbc.id "
                        + "       from tipo_instrumento_ensaio tpbc"
                        + "     where tpbc.e_componente = 'N' )")
                        .filter("BANC.NOME", form.get("BANC_NOME"))
                        ;
                base.setBancadaEnsaioId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // MODELO_HIDROMETRO_ID
        try {
            if (form.hasFields("MLDH_CODIGO")) {
                query = createQuery()
                        .select("MLDH.ID")
                        .from("MODELO_HIDROMETRO", "MLDH")
                        .filter("MLDH.CODIGO", form.get("MLDH_CODIGO"))
                        ;
                base.setModeloHidrometroId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // OPERADOR_ENSAIO_ID
        try {
            if (form.hasFields("OPER_NOME_APRESENTACAO")) {
                query = createQuery()
                        .select("OPER.ID")
                        .from("PESSOA", "OPER")
                        .where("oper.ativo = 'S' and oper.usuario_associado_id is not null")
                        .filter("OPER.NOME_APRESENTACAO", form.get("OPER_NOME_APRESENTACAO"))
                        ;
                base.setOperadorEnsaioId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // PLANO_EXECUCAO_ID
        try {
            if (form.hasFields("PLEX_NOME")) {
                query = createQuery()
                        .select("PLEX.ID")
                        .from("PLANO_EXECUCAO", "PLEX")
                        .where("plex.situacao = 'A'")
                        .filter("PLEX.NOME", form.get("PLEX_NOME"))
                        ;
                base.setPlanoExecucaoId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @Override
    public ModuleNavigator getDefaultModuleNavigator() {
        return new ModEnsaioLivre();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="QUERY">
    public class FQuery extends QueryFeature {
        
        @Override
        public void initForm() {
            addField(qSequenciaAutomatica, "opt");
            addField(qBancNome, "opt");
            addField(qTpbcNome, "opt");
            addField(qMldhCodigo, "opt");
            addField(qPlexNome, "opt");
            addField(qOperNomeApresentacao, "opt");
            addField(qOperCodigo, "opt");
            addField(qUoprLogin, "opt");
            addField(qSituacao, "opt");
            addField(qSituacaoEnsaioHidrostatico, "opt");
            addField(qSituacaoEnsaioVisual, "opt");
            addField(qDataInicioEnsaio, "opt");
            addField(qDataFimEnsaio, "opt");
            addField(qQuantidadeHidrometros, "opt");
        }
        
        {
            setFeatureName("QUERY");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="LIST">
    public class FList extends ListFeature {
        
        @Override
        public void initForm() {
            addField(aSequenciaAutomatica, "view");
            addField(aBancNome, "view");
            addField(aTpbcNome, "view");
            addField(aMldhCodigo, "view");
            addField(aOperNomeApresentacao, "view");
            addField(aSituacao, "view");
            addField(aDataInicioEnsaio, "view");
            addField(aHoraInicioEnsaio, "view");
            addField(aHoraFimEnsaio, "view");
        }
        
        {
            setFeatureName("LIST");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="VIEW">
    public class FView extends ViewFeature {
        
        @Override
        public void initForm() {
            addField(aSequenciaAutomatica, "view");
            addField(aBancNome, "view");
            addField(aTpbcNome, "view");
            addField(aMldhCodigo, "view");
            addField(aMldhDescricao, "view");
            addField(aPlexNome, "view");
            addField(aPlexSituacao, "view");
            addField(aOperNomeApresentacao, "view");
            addField(aOperAtivo, "view");
            addField(aOperCodigo, "view");
            addField(aUoprLogin, "view");
            addField(aSituacao, "view");
            addField(aSituacaoEnsaioHidrostatico, "view");
            addField(aSituacaoEnsaioVisual, "view");
            addField(aDataInicioEnsaio, "view");
            addField(aHoraInicioEnsaio, "view");
            addField(aDataFimEnsaio, "view");
            addField(aHoraFimEnsaio, "view");
            addField(aNumeroLaudo, "view");
            addField(aQuantidadeHidrometros, "view");
            addField(aQuantidadeHidrometrosAprovados, "view");
            addField(aQuantidadeHidrometrosReprovados, "view");
        }
        
        @Override
        public void preDisplay() {
            try {
                desabilitarAcoesInterface();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        {
            setFeatureName("VIEW");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="INSERT">
    public class FInsert extends InsertFeature {
        
        @Override
        public void initForm() {
            aBancNome.setOptional(false);
            addField(aBancNome, "rqd");
            aTpbcNome.setEditable(false);
            addField(aTpbcNome, "view");
            aMldhCodigo.setOptional(false);
            addField(aMldhCodigo, "rqd");
            aMldhDescricao.setEditable(false);
            addField(aMldhDescricao, "view");
            aPlexNome.setOptional(false);
            addField(aPlexNome, "rqd");
            aPlexSituacao.setEditable(false);
            addField(aPlexSituacao, "view");
            aOperNomeApresentacao.setOptional(false);
            addField(aOperNomeApresentacao, "rqd");
            aOperAtivo.setEditable(false);
            addField(aOperAtivo, "view");
            aOperCodigo.setEditable(false);
            addField(aOperCodigo, "view");
            aUoprLogin.setEditable(false);
            addField(aUoprLogin, "view");
            aSituacao.setEditable(false);
            addField(aSituacao, "view");
            aSituacaoEnsaioHidrostatico.setEditable(false);
            addField(aSituacaoEnsaioHidrostatico, "view");
            aSituacaoEnsaioVisual.setEditable(false);
            addField(aSituacaoEnsaioVisual, "view");
            aQuantidadeHidrometros.setOptional(false);
            addField(aQuantidadeHidrometros, "rqd");
        }
        
        {
            setFeatureName("INSERT");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="UPDATE">
    public class FUpdate extends UpdateFeature {
        
        @Override
        public void initForm() {
            aSequenciaAutomatica.setEditable(false);
            addField(aSequenciaAutomatica, "view");
            aBancNome.setOptional(false);
            addField(aBancNome, "rqd");
            aTpbcNome.setEditable(false);
            addField(aTpbcNome, "view");
            aMldhCodigo.setOptional(false);
            addField(aMldhCodigo, "rqd");
            aMldhDescricao.setEditable(false);
            addField(aMldhDescricao, "view");
            aPlexNome.setOptional(false);
            addField(aPlexNome, "rqd");
            aPlexSituacao.setEditable(false);
            addField(aPlexSituacao, "view");
            aOperNomeApresentacao.setOptional(false);
            addField(aOperNomeApresentacao, "rqd");
            aOperAtivo.setEditable(false);
            addField(aOperAtivo, "view");
            aOperCodigo.setEditable(false);
            addField(aOperCodigo, "view");
            aUoprLogin.setEditable(false);
            addField(aUoprLogin, "view");
            aSituacao.setEditable(false);
            addField(aSituacao, "view");
            aSituacaoEnsaioHidrostatico.setEditable(false);
            addField(aSituacaoEnsaioHidrostatico, "view");
            aSituacaoEnsaioVisual.setEditable(false);
            addField(aSituacaoEnsaioVisual, "view");
            aDataInicioEnsaio.setEditable(false);
            addField(aDataInicioEnsaio, "view");
            aHoraInicioEnsaio.setOptional(false);
            addField(aHoraInicioEnsaio, "rqd");
            aDataFimEnsaio.setEditable(false);
            addField(aDataFimEnsaio, "view");
            aHoraFimEnsaio.setEditable(false);
            addField(aHoraFimEnsaio, "view");
            addField(aNumeroLaudo, "opt");
            aQuantidadeHidrometros.setOptional(false);
            addField(aQuantidadeHidrometros, "rqd");
            aQuantidadeHidrometrosAprovados.setEditable(false);
            addField(aQuantidadeHidrometrosAprovados, "view");
            aQuantidadeHidrometrosReprovados.setEditable(false);
            addField(aQuantidadeHidrometrosReprovados, "view");
        }
        
        {
            setFeatureName("UPDATE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="DELETE">
    public class FDelete extends DeleteFeature {
        
        @Override
        public void initForm() {
            addField(aSequenciaAutomatica, "view");
            addField(aBancNome, "view");
            addField(aTpbcNome, "view");
            addField(aMldhCodigo, "view");
            addField(aPlexNome, "view");
            addField(aOperNomeApresentacao, "view");
            addField(aSituacao, "view");
            addField(aNumeroLaudo, "view");
        }
        
        {
            setFeatureName("DELETE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="BANC_NOME_LOOKUP">
    public class FBancNomeLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aBancNome.setEditable(true);
            addField(aBancNome, "opt");
            aTpbcNome.setEditable(false);
            addField(aTpbcNome, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("BANC.NOME as BANC_NOME")
                    .select("TPBC.NOME as TPBC_NOME")
                    .from("INSTRUMENTO_ENSAIO", "BANC")
                    .leftJoin("TIPO_INSTRUMENTO_ENSAIO", "TPBC", "TPBC.ID = BANC.TIPO_INSTRUMENTO_ENSAIO_ID")
                    .where("banc.tipo_instrumento_ensaio_id in "
                    + "    (select tpbc.id "
                    + "       from tipo_instrumento_ensaio tpbc"
                    + "     where tpbc.e_componente = 'N' )")
                    ;
        }
        
        {
            setFeatureName("BANC_NOME_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="MLDH_CODIGO_LOOKUP">
    public class FMldhCodigoLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aMldhCodigo.setEditable(true);
            addField(aMldhCodigo, "opt");
            aMldhDescricao.setEditable(false);
            addField(aMldhDescricao, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("MLDH.CODIGO as MLDH_CODIGO")
                    .select("MLDH.DESCRICAO as MLDH_DESCRICAO")
                    .from("MODELO_HIDROMETRO", "MLDH")
                    ;
        }
        
        {
            setFeatureName("MLDH_CODIGO_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="OPER_NOME_APRESENTACAO_LOOKUP">
    public class FOperNomeApresentacaoLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aOperNomeApresentacao.setEditable(true);
            addField(aOperNomeApresentacao, "opt");
            aOperAtivo.setEditable(false);
            addField(aOperAtivo, "view");
            aOperCodigo.setEditable(false);
            addField(aOperCodigo, "view");
            aOperTipoPessoaId.setEditable(false);
            addField(aOperTipoPessoaId, "view");
            aUoprLogin.setEditable(false);
            addField(aUoprLogin, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("OPER.NOME_APRESENTACAO as OPER_NOME_APRESENTACAO")
                    .select("OPER.ATIVO as OPER_ATIVO")
                    .select("OPER.CODIGO as OPER_CODIGO")
                    .select("OPER.TIPO_PESSOA_ID as OPER_TIPO_PESSOA_ID")
                    .select("UOPR.LOGIN as UOPR_LOGIN")
                    .from("PESSOA", "OPER")
                    .leftJoin("USUARIOS", "UOPR", "UOPR.ID = OPER.USUARIO_ASSOCIADO_ID")
                    .where("oper.ativo = 'S' and oper.usuario_associado_id is not null")
                    ;
        }
        
        {
            setFeatureName("OPER_NOME_APRESENTACAO_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="PLEX_NOME_LOOKUP">
    public class FPlexNomeLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aPlexNome.setEditable(true);
            addField(aPlexNome, "opt");
            aPlexSituacao.setEditable(false);
            addField(aPlexSituacao, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("PLEX.NOME as PLEX_NOME")
                    .select("PLEX.SITUACAO as PLEX_SITUACAO")
                    .from("PLANO_EXECUCAO", "PLEX")
                    .where("plex.situacao = 'A'")
                    ;
        }
        
        {
            setFeatureName("PLEX_NOME_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="initFeatures">
    
    @Override
    protected void initFeatures() {
        addFeature(new FQuery());
        addFeature(new FList());
        addFeature(new FView());
        addFeature(new FInsert());
        addFeature(new FUpdate());
        addFeature(new FDelete());
        addFeature(new FBancNomeLookup());
        addFeature(new FMldhCodigoLookup());
        addFeature(new FOperNomeApresentacaoLookup());
        addFeature(new FPlexNomeLookup());
        super.initFeatures();
    }
    
    @Override
    public String getDefaultFeature() {
        return "QUERY";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Getters and Setters">
    
    public Long getSequenciaAutomatica() {
        return aSequenciaAutomatica.getValue();
    }
    
    public void setSequenciaAutomatica(Long value) {
        this.aSequenciaAutomatica.setValue(value);
    }
    
    public String getSituacao() {
        return aSituacao.getValue();
    }
    
    public void setSituacao(String value) {
        this.aSituacao.setValue(value);
    }
    
    public String getSituacaoEnsaioHidrostatico() {
        return aSituacaoEnsaioHidrostatico.getValue();
    }
    
    public void setSituacaoEnsaioHidrostatico(String value) {
        this.aSituacaoEnsaioHidrostatico.setValue(value);
    }
    
    public String getSituacaoEnsaioVisual() {
        return aSituacaoEnsaioVisual.getValue();
    }
    
    public void setSituacaoEnsaioVisual(String value) {
        this.aSituacaoEnsaioVisual.setValue(value);
    }
    
    public java.sql.Date getDataInicioEnsaio() {
        return aDataInicioEnsaio.getValue();
    }
    
    public void setDataInicioEnsaio(java.sql.Date value) {
        this.aDataInicioEnsaio.setValue(value);
    }
    
    public java.sql.Time getHoraInicioEnsaio() {
        return aHoraInicioEnsaio.getValue();
    }
    
    public void setHoraInicioEnsaio(java.sql.Time value) {
        this.aHoraInicioEnsaio.setValue(value);
    }
    
    public java.sql.Date getDataFimEnsaio() {
        return aDataFimEnsaio.getValue();
    }
    
    public void setDataFimEnsaio(java.sql.Date value) {
        this.aDataFimEnsaio.setValue(value);
    }
    
    public java.sql.Time getHoraFimEnsaio() {
        return aHoraFimEnsaio.getValue();
    }
    
    public void setHoraFimEnsaio(java.sql.Time value) {
        this.aHoraFimEnsaio.setValue(value);
    }
    
    public String getNumeroLaudo() {
        return aNumeroLaudo.getValue();
    }
    
    public void setNumeroLaudo(String value) {
        this.aNumeroLaudo.setValue(value);
    }
    
    public Integer getQuantidadeHidrometros() {
        return aQuantidadeHidrometros.getValue();
    }
    
    public void setQuantidadeHidrometros(Integer value) {
        this.aQuantidadeHidrometros.setValue(value);
    }
    
    public Integer getQuantidadeHidrometrosAprovados() {
        return aQuantidadeHidrometrosAprovados.getValue();
    }
    
    public void setQuantidadeHidrometrosAprovados(Integer value) {
        this.aQuantidadeHidrometrosAprovados.setValue(value);
    }
    
    public Integer getQuantidadeHidrometrosReprovados() {
        return aQuantidadeHidrometrosReprovados.getValue();
    }
    
    public void setQuantidadeHidrometrosReprovados(Integer value) {
        this.aQuantidadeHidrometrosReprovados.setValue(value);
    }
    
    @Override
    public Long getId() {
        return aId.getValue();
    }
    
    public void setId(Long value) {
        this.aId.setValue(value);
    }
    
    public Long getSolicitacaoEnsaioId() {
        return aSolicitacaoEnsaioId.getValue();
    }
    
    public void setSolicitacaoEnsaioId(Long value) {
        this.aSolicitacaoEnsaioId.setValue(value);
    }
    
    public Long getBancadaEnsaioId() {
        return aBancadaEnsaioId.getValue();
    }
    
    public void setBancadaEnsaioId(Long value) {
        this.aBancadaEnsaioId.setValue(value);
    }
    
    public Long getOperadorEnsaioId() {
        return aOperadorEnsaioId.getValue();
    }
    
    public void setOperadorEnsaioId(Long value) {
        this.aOperadorEnsaioId.setValue(value);
    }
    
    public Long getPlanoExecucaoId() {
        return aPlanoExecucaoId.getValue();
    }
    
    public void setPlanoExecucaoId(Long value) {
        this.aPlanoExecucaoId.setValue(value);
    }
    
    public Long getModeloHidrometroId() {
        return aModeloHidrometroId.getValue();
    }
    
    public void setModeloHidrometroId(Long value) {
        this.aModeloHidrometroId.setValue(value);
    }
    
    public String getBancNome() {
        return aBancNome.getValue();
    }
    
    public void setBancNome(String value) {
        this.aBancNome.setValue(value);
    }
    
    public String getMldhCodigo() {
        return aMldhCodigo.getValue();
    }
    
    public void setMldhCodigo(String value) {
        this.aMldhCodigo.setValue(value);
    }
    
    public String getMldhDescricao() {
        return aMldhDescricao.getValue();
    }
    
    public void setMldhDescricao(String value) {
        this.aMldhDescricao.setValue(value);
    }
    
    public String getOperNomeApresentacao() {
        return aOperNomeApresentacao.getValue();
    }
    
    public void setOperNomeApresentacao(String value) {
        this.aOperNomeApresentacao.setValue(value);
    }
    
    public String getOperAtivo() {
        return aOperAtivo.getValue();
    }
    
    public void setOperAtivo(String value) {
        this.aOperAtivo.setValue(value);
    }
    
    public String getOperCodigo() {
        return aOperCodigo.getValue();
    }
    
    public void setOperCodigo(String value) {
        this.aOperCodigo.setValue(value);
    }
    
    public Long getOperTipoPessoaId() {
        return aOperTipoPessoaId.getValue();
    }
    
    public void setOperTipoPessoaId(Long value) {
        this.aOperTipoPessoaId.setValue(value);
    }
    
    public String getPlexNome() {
        return aPlexNome.getValue();
    }
    
    public void setPlexNome(String value) {
        this.aPlexNome.setValue(value);
    }
    
    public String getPlexSituacao() {
        return aPlexSituacao.getValue();
    }
    
    public void setPlexSituacao(String value) {
        this.aPlexSituacao.setValue(value);
    }
    
    public String getTpbcNome() {
        return aTpbcNome.getValue();
    }
    
    public void setTpbcNome(String value) {
        this.aTpbcNome.setValue(value);
    }
    
    public String getUoprLogin() {
        return aUoprLogin.getValue();
    }
    
    public void setUoprLogin(String value) {
        this.aUoprLogin.setValue(value);
    }
    public String getQuerySequenciaAutomatica() {
        return qSequenciaAutomatica.getQueryValue();
    }
    
    public void setQuerySequenciaAutomatica(String value) {
        this.qSequenciaAutomatica.setQueryValue(value);
    }
    public String getQueryBancNome() {
        return qBancNome.getQueryValue();
    }
    
    public void setQueryBancNome(String value) {
        this.qBancNome.setQueryValue(value);
    }
    public String getQueryTpbcNome() {
        return qTpbcNome.getQueryValue();
    }
    
    public void setQueryTpbcNome(String value) {
        this.qTpbcNome.setQueryValue(value);
    }
    public String getQueryMldhCodigo() {
        return qMldhCodigo.getQueryValue();
    }
    
    public void setQueryMldhCodigo(String value) {
        this.qMldhCodigo.setQueryValue(value);
    }
    public String getQueryPlexNome() {
        return qPlexNome.getQueryValue();
    }
    
    public void setQueryPlexNome(String value) {
        this.qPlexNome.setQueryValue(value);
    }
    public String getQueryOperNomeApresentacao() {
        return qOperNomeApresentacao.getQueryValue();
    }
    
    public void setQueryOperNomeApresentacao(String value) {
        this.qOperNomeApresentacao.setQueryValue(value);
    }
    public String getQueryOperCodigo() {
        return qOperCodigo.getQueryValue();
    }
    
    public void setQueryOperCodigo(String value) {
        this.qOperCodigo.setQueryValue(value);
    }
    public String getQueryUoprLogin() {
        return qUoprLogin.getQueryValue();
    }
    
    public void setQueryUoprLogin(String value) {
        this.qUoprLogin.setQueryValue(value);
    }
    public String getQuerySituacao() {
        return qSituacao.getQueryValue();
    }
    
    public void setQuerySituacao(String value) {
        this.qSituacao.setQueryValue(value);
    }
    public String getQuerySituacaoEnsaioHidrostatico() {
        return qSituacaoEnsaioHidrostatico.getQueryValue();
    }
    
    public void setQuerySituacaoEnsaioHidrostatico(String value) {
        this.qSituacaoEnsaioHidrostatico.setQueryValue(value);
    }
    public String getQuerySituacaoEnsaioVisual() {
        return qSituacaoEnsaioVisual.getQueryValue();
    }
    
    public void setQuerySituacaoEnsaioVisual(String value) {
        this.qSituacaoEnsaioVisual.setQueryValue(value);
    }
    public String getQueryDataInicioEnsaio() {
        return qDataInicioEnsaio.getQueryValue();
    }
    
    public void setQueryDataInicioEnsaio(String value) {
        this.qDataInicioEnsaio.setQueryValue(value);
    }
    public String getQueryDataFimEnsaio() {
        return qDataFimEnsaio.getQueryValue();
    }
    
    public void setQueryDataFimEnsaio(String value) {
        this.qDataFimEnsaio.setQueryValue(value);
    }
    public String getQueryQuantidadeHidrometros() {
        return qQuantidadeHidrometros.getQueryValue();
    }
    
    public void setQueryQuantidadeHidrometros(String value) {
        this.qQuantidadeHidrometros.setQueryValue(value);
    }
    
    public Long getParameterIdSolicitacaoEnsaio() {
        return pIdSolicitacaoEnsaio.getValue();
    }
    
    public void setParameterIdSolicitacaoEnsaio(Long value) {
        pIdSolicitacaoEnsaio.setValue(value);
        aSolicitacaoEnsaioId.setValue(value);
    }
    // </editor-fold>
    
    /**
     * Desabilitar ações da interface.
     */
    private void desabilitarAcoesInterface() throws AdsException {
        // <user-code id="22042255" parentId="22042248" hashcode="9c10677" length="124">
        if (!getRecord().valueOfSituacao().equals("P")) {
            getForm().delAction("UPDATE");
            getForm().delAction("DELETE");
        }
        // </user-code>
    }
    
    @Override
    public String getJsServiceFile() {
        return "ui/ztest/cad_ensaio_livre.js";
    }
}
